// $ANTLR 3.4 C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g 2012-10-25 16:36:52
package PL.practica6;

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked"})
public class AnalizadorANTLRLexer extends Lexer {
    public static final int EOF=-1;
    public static final int ABRIRLLAVE=4;
    public static final int ABRIRPARENTESIS=5;
    public static final int ARROBA=6;
    public static final int ASTERISCO=7;
    public static final int BLANCO=8;
    public static final int CARACTER=9;
    public static final int CERRARLLAVE=10;
    public static final int CERRARPARENTESIS=11;
    public static final int COMENTARIO=12;
    public static final int COMENTARIOlINEA=13;
    public static final int DIGITO=14;
    public static final int DOSPUNTOS=15;
    public static final int GRAMMAR=16;
    public static final int HEADER=17;
    public static final int IDENT=18;
    public static final int IDENTREGLA=19;
    public static final int IDENTTOKEN=20;
    public static final int IGUAL=21;
    public static final int IMPORT=22;
    public static final int INTERROGANTE=23;
    public static final int LETRA=24;
    public static final int LETRAMAYUSCULA=25;
    public static final int LETRAMINUSCULA=26;
    public static final int MEMBERS=27;
    public static final int NUEVA_LINEA=28;
    public static final int OPERADORUNITARIO=29;
    public static final int OPTIONS=30;
    public static final int OR=31;
    public static final int PACKAGE=32;
    public static final int PARSER=33;
    public static final int SEPARADOR=34;
    public static final int SUMA=35;


    ArrayList <RecognitionException> errores = new ArrayList<RecognitionException>();

    public boolean listaVacia (){
        if (errores.isEmpty()){
          return true;
        }else
          return false;
    }

    public ArrayList getListaErrores(){return errores;}


    @Override
    public void reportError (RecognitionException e){
      System.out.println (getErrorMessage(e, getTokenNames()));
      errores.add(e);
    }



    // delegates
    // delegators
    public Lexer[] getDelegates() {
        return new Lexer[] {};
    }

    public AnalizadorANTLRLexer() {} 
    public AnalizadorANTLRLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public AnalizadorANTLRLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);
    }
    public String getGrammarFileName() { return "C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g"; }

    // $ANTLR start "HEADER"
    public final void mHEADER() throws RecognitionException {
        try {
            int _type = HEADER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:31:10: ( 'header' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:31:12: 'header'
            {
            match("header"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "HEADER"

    // $ANTLR start "OPTIONS"
    public final void mOPTIONS() throws RecognitionException {
        try {
            int _type = OPTIONS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:32:11: ( 'options' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:32:13: 'options'
            {
            match("options"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "OPTIONS"

    // $ANTLR start "PARSER"
    public final void mPARSER() throws RecognitionException {
        try {
            int _type = PARSER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:33:10: ( 'parser' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:33:12: 'parser'
            {
            match("parser"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "PARSER"

    // $ANTLR start "GRAMMAR"
    public final void mGRAMMAR() throws RecognitionException {
        try {
            int _type = GRAMMAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:34:11: ( 'grammar' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:34:13: 'grammar'
            {
            match("grammar"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "GRAMMAR"

    // $ANTLR start "IMPORT"
    public final void mIMPORT() throws RecognitionException {
        try {
            int _type = IMPORT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:35:10: ( 'import' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:35:12: 'import'
            {
            match("import"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "IMPORT"

    // $ANTLR start "PACKAGE"
    public final void mPACKAGE() throws RecognitionException {
        try {
            int _type = PACKAGE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:36:11: ( 'package' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:36:13: 'package'
            {
            match("package"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "PACKAGE"

    // $ANTLR start "MEMBERS"
    public final void mMEMBERS() throws RecognitionException {
        try {
            int _type = MEMBERS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:37:11: ( 'members' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:37:13: 'members'
            {
            match("members"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "MEMBERS"

    // $ANTLR start "ARROBA"
    public final void mARROBA() throws RecognitionException {
        try {
            int _type = ARROBA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:38:10: ( '@' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:38:12: '@'
            {
            match('@'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ARROBA"

    // $ANTLR start "ABRIRLLAVE"
    public final void mABRIRLLAVE() throws RecognitionException {
        try {
            int _type = ABRIRLLAVE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:39:13: ( '{' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:39:15: '{'
            {
            match('{'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ABRIRLLAVE"

    // $ANTLR start "CERRARLLAVE"
    public final void mCERRARLLAVE() throws RecognitionException {
        try {
            int _type = CERRARLLAVE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:40:15: ( '}' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:40:17: '}'
            {
            match('}'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CERRARLLAVE"

    // $ANTLR start "COMENTARIO"
    public final void mCOMENTARIO() throws RecognitionException {
        try {
            int _type = COMENTARIO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:41:13: ( '/*' ( options {greedy=false; } : . )* '*/' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:41:15: '/*' ( options {greedy=false; } : . )* '*/'
            {
            match("/*"); 



            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:41:20: ( options {greedy=false; } : . )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0=='*') ) {
                    int LA1_1 = input.LA(2);

                    if ( (LA1_1=='/') ) {
                        alt1=2;
                    }
                    else if ( ((LA1_1 >= '\u0000' && LA1_1 <= '.')||(LA1_1 >= '0' && LA1_1 <= '\uFFFF')) ) {
                        alt1=1;
                    }


                }
                else if ( ((LA1_0 >= '\u0000' && LA1_0 <= ')')||(LA1_0 >= '+' && LA1_0 <= '\uFFFF')) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:41:45: .
            	    {
            	    matchAny(); 

            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            match("*/"); 



            skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMENTARIO"

    // $ANTLR start "NUEVA_LINEA"
    public final void mNUEVA_LINEA() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:42:23: ( '\\r\\n' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:42:25: '\\r\\n'
            {
            match("\r\n"); 



            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "NUEVA_LINEA"

    // $ANTLR start "COMENTARIOlINEA"
    public final void mCOMENTARIOlINEA() throws RecognitionException {
        try {
            int _type = COMENTARIOlINEA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:43:19: ( '//' ( options {greedy=false; } : . )* NUEVA_LINEA )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:43:21: '//' ( options {greedy=false; } : . )* NUEVA_LINEA
            {
            match("//"); 



            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:43:26: ( options {greedy=false; } : . )*
            loop2:
            do {
                int alt2=2;
                int LA2_0 = input.LA(1);

                if ( (LA2_0=='\r') ) {
                    int LA2_1 = input.LA(2);

                    if ( (LA2_1=='\n') ) {
                        alt2=2;
                    }
                    else if ( ((LA2_1 >= '\u0000' && LA2_1 <= '\t')||(LA2_1 >= '\u000B' && LA2_1 <= '\uFFFF')) ) {
                        alt2=1;
                    }


                }
                else if ( ((LA2_0 >= '\u0000' && LA2_0 <= '\f')||(LA2_0 >= '\u000E' && LA2_0 <= '\uFFFF')) ) {
                    alt2=1;
                }


                switch (alt2) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:43:51: .
            	    {
            	    matchAny(); 

            	    }
            	    break;

            	default :
            	    break loop2;
                }
            } while (true);


            mNUEVA_LINEA(); 


            skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMENTARIOlINEA"

    // $ANTLR start "BLANCO"
    public final void mBLANCO() throws RecognitionException {
        try {
            int _type = BLANCO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:44:9: ( ( ' ' | '\\t' | NUEVA_LINEA ) )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:44:11: ( ' ' | '\\t' | NUEVA_LINEA )
            {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:44:11: ( ' ' | '\\t' | NUEVA_LINEA )
            int alt3=3;
            switch ( input.LA(1) ) {
            case ' ':
                {
                alt3=1;
                }
                break;
            case '\t':
                {
                alt3=2;
                }
                break;
            case '\r':
                {
                alt3=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;

            }

            switch (alt3) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:44:12: ' '
                    {
                    match(' '); 

                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:44:16: '\\t'
                    {
                    match('\t'); 

                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:44:21: NUEVA_LINEA
                    {
                    mNUEVA_LINEA(); 


                    }
                    break;

            }


            skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "BLANCO"

    // $ANTLR start "CARACTER"
    public final void mCARACTER() throws RecognitionException {
        try {
            int _type = CARACTER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:45:12: ( '\\'' ( LETRAMAYUSCULA | LETRAMINUSCULA | DIGITO ) '\\'' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:45:14: '\\'' ( LETRAMAYUSCULA | LETRAMINUSCULA | DIGITO ) '\\''
            {
            match('\''); 

            if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            match('\''); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CARACTER"

    // $ANTLR start "DIGITO"
    public final void mDIGITO() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:46:18: ( '0' .. '9' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:
            {
            if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "DIGITO"

    // $ANTLR start "LETRAMINUSCULA"
    public final void mLETRAMINUSCULA() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:47:27: ( ( 'a' .. 'z' ) | '_' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:
            {
            if ( input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LETRAMINUSCULA"

    // $ANTLR start "LETRAMAYUSCULA"
    public final void mLETRAMAYUSCULA() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:48:27: ( ( 'A' .. 'Z' ) | '_' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:
            {
            if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_' ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LETRAMAYUSCULA"

    // $ANTLR start "LETRA"
    public final void mLETRA() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:49:18: ( ( 'a' .. 'z' ) | ( 'A' .. 'Z' ) | '.' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:
            {
            if ( input.LA(1)=='.'||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LETRA"

    // $ANTLR start "IDENT"
    public final void mIDENT() throws RecognitionException {
        try {
            int _type = IDENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:50:9: ( LETRA ( LETRA | DIGITO )+ )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:50:11: LETRA ( LETRA | DIGITO )+
            {
            mLETRA(); 


            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:50:17: ( LETRA | DIGITO )+
            int cnt4=0;
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( (LA4_0=='.'||(LA4_0 >= '0' && LA4_0 <= '9')||(LA4_0 >= 'A' && LA4_0 <= 'Z')||(LA4_0 >= 'a' && LA4_0 <= 'z')) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:
            	    {
            	    if ( input.LA(1)=='.'||(input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt4 >= 1 ) break loop4;
                        EarlyExitException eee =
                            new EarlyExitException(4, input);
                        throw eee;
                }
                cnt4++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "IDENT"

    // $ANTLR start "OR"
    public final void mOR() throws RecognitionException {
        try {
            int _type = OR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:51:6: ( '|' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:51:8: '|'
            {
            match('|'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "OR"

    // $ANTLR start "SEPARADOR"
    public final void mSEPARADOR() throws RecognitionException {
        try {
            int _type = SEPARADOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:52:12: ( ';' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:52:14: ';'
            {
            match(';'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "SEPARADOR"

    // $ANTLR start "DOSPUNTOS"
    public final void mDOSPUNTOS() throws RecognitionException {
        try {
            int _type = DOSPUNTOS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:53:12: ( ':' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:53:14: ':'
            {
            match(':'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "DOSPUNTOS"

    // $ANTLR start "ASTERISCO"
    public final void mASTERISCO() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:54:21: ( '*' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:54:23: '*'
            {
            match('*'); 

            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ASTERISCO"

    // $ANTLR start "INTERROGANTE"
    public final void mINTERROGANTE() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:55:25: ( '?' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:55:27: '?'
            {
            match('?'); 

            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "INTERROGANTE"

    // $ANTLR start "SUMA"
    public final void mSUMA() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:56:17: ( '+' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:56:19: '+'
            {
            match('+'); 

            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "SUMA"

    // $ANTLR start "OPERADORUNITARIO"
    public final void mOPERADORUNITARIO() throws RecognitionException {
        try {
            int _type = OPERADORUNITARIO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:57:20: ( ASTERISCO | INTERROGANTE | SUMA )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:
            {
            if ( (input.LA(1) >= '*' && input.LA(1) <= '+')||input.LA(1)=='?' ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "OPERADORUNITARIO"

    // $ANTLR start "ABRIRPARENTESIS"
    public final void mABRIRPARENTESIS() throws RecognitionException {
        try {
            int _type = ABRIRPARENTESIS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:58:19: ( '(' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:58:21: '('
            {
            match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ABRIRPARENTESIS"

    // $ANTLR start "CERRARPARENTESIS"
    public final void mCERRARPARENTESIS() throws RecognitionException {
        try {
            int _type = CERRARPARENTESIS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:59:20: ( ')' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:59:22: ')'
            {
            match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CERRARPARENTESIS"

    // $ANTLR start "IDENTREGLA"
    public final void mIDENTREGLA() throws RecognitionException {
        try {
            int _type = IDENTREGLA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:60:14: ( LETRAMINUSCULA ( LETRAMAYUSCULA | LETRAMINUSCULA | DIGITO )+ )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:60:16: LETRAMINUSCULA ( LETRAMAYUSCULA | LETRAMINUSCULA | DIGITO )+
            {
            mLETRAMINUSCULA(); 


            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:60:31: ( LETRAMAYUSCULA | LETRAMINUSCULA | DIGITO )+
            int cnt5=0;
            loop5:
            do {
                int alt5=2;
                int LA5_0 = input.LA(1);

                if ( ((LA5_0 >= '0' && LA5_0 <= '9')||(LA5_0 >= 'A' && LA5_0 <= 'Z')||LA5_0=='_'||(LA5_0 >= 'a' && LA5_0 <= 'z')) ) {
                    alt5=1;
                }


                switch (alt5) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:
            	    {
            	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt5 >= 1 ) break loop5;
                        EarlyExitException eee =
                            new EarlyExitException(5, input);
                        throw eee;
                }
                cnt5++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "IDENTREGLA"

    // $ANTLR start "IDENTTOKEN"
    public final void mIDENTTOKEN() throws RecognitionException {
        try {
            int _type = IDENTTOKEN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:61:14: ( LETRAMAYUSCULA ( LETRAMAYUSCULA | LETRAMINUSCULA | DIGITO )+ )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:61:16: LETRAMAYUSCULA ( LETRAMAYUSCULA | LETRAMINUSCULA | DIGITO )+
            {
            mLETRAMAYUSCULA(); 


            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:61:31: ( LETRAMAYUSCULA | LETRAMINUSCULA | DIGITO )+
            int cnt6=0;
            loop6:
            do {
                int alt6=2;
                int LA6_0 = input.LA(1);

                if ( ((LA6_0 >= '0' && LA6_0 <= '9')||(LA6_0 >= 'A' && LA6_0 <= 'Z')||LA6_0=='_'||(LA6_0 >= 'a' && LA6_0 <= 'z')) ) {
                    alt6=1;
                }


                switch (alt6) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:
            	    {
            	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt6 >= 1 ) break loop6;
                        EarlyExitException eee =
                            new EarlyExitException(6, input);
                        throw eee;
                }
                cnt6++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "IDENTTOKEN"

    // $ANTLR start "IGUAL"
    public final void mIGUAL() throws RecognitionException {
        try {
            int _type = IGUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:62:9: ( '=' )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:62:11: '='
            {
            match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "IGUAL"

    public void mTokens() throws RecognitionException {
        // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:8: ( HEADER | OPTIONS | PARSER | GRAMMAR | IMPORT | PACKAGE | MEMBERS | ARROBA | ABRIRLLAVE | CERRARLLAVE | COMENTARIO | COMENTARIOlINEA | BLANCO | CARACTER | IDENT | OR | SEPARADOR | DOSPUNTOS | OPERADORUNITARIO | ABRIRPARENTESIS | CERRARPARENTESIS | IDENTREGLA | IDENTTOKEN | IGUAL )
        int alt7=24;
        alt7 = dfa7.predict(input);
        switch (alt7) {
            case 1 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:10: HEADER
                {
                mHEADER(); 


                }
                break;
            case 2 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:17: OPTIONS
                {
                mOPTIONS(); 


                }
                break;
            case 3 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:25: PARSER
                {
                mPARSER(); 


                }
                break;
            case 4 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:32: GRAMMAR
                {
                mGRAMMAR(); 


                }
                break;
            case 5 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:40: IMPORT
                {
                mIMPORT(); 


                }
                break;
            case 6 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:47: PACKAGE
                {
                mPACKAGE(); 


                }
                break;
            case 7 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:55: MEMBERS
                {
                mMEMBERS(); 


                }
                break;
            case 8 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:63: ARROBA
                {
                mARROBA(); 


                }
                break;
            case 9 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:70: ABRIRLLAVE
                {
                mABRIRLLAVE(); 


                }
                break;
            case 10 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:81: CERRARLLAVE
                {
                mCERRARLLAVE(); 


                }
                break;
            case 11 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:93: COMENTARIO
                {
                mCOMENTARIO(); 


                }
                break;
            case 12 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:104: COMENTARIOlINEA
                {
                mCOMENTARIOlINEA(); 


                }
                break;
            case 13 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:120: BLANCO
                {
                mBLANCO(); 


                }
                break;
            case 14 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:127: CARACTER
                {
                mCARACTER(); 


                }
                break;
            case 15 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:136: IDENT
                {
                mIDENT(); 


                }
                break;
            case 16 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:142: OR
                {
                mOR(); 


                }
                break;
            case 17 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:145: SEPARADOR
                {
                mSEPARADOR(); 


                }
                break;
            case 18 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:155: DOSPUNTOS
                {
                mDOSPUNTOS(); 


                }
                break;
            case 19 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:165: OPERADORUNITARIO
                {
                mOPERADORUNITARIO(); 


                }
                break;
            case 20 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:182: ABRIRPARENTESIS
                {
                mABRIRPARENTESIS(); 


                }
                break;
            case 21 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:198: CERRARPARENTESIS
                {
                mCERRARPARENTESIS(); 


                }
                break;
            case 22 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:215: IDENTREGLA
                {
                mIDENTREGLA(); 


                }
                break;
            case 23 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:226: IDENTTOKEN
                {
                mIDENTTOKEN(); 


                }
                break;
            case 24 :
                // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRLexer.g:1:237: IGUAL
                {
                mIGUAL(); 


                }
                break;

        }

    }


    protected DFA7 dfa7 = new DFA7(this);
    static final String DFA7_eotS =
        "\30\uffff\2\26\1\uffff\5\26\2\uffff\1\26\1\uffff\1\32\25\26\1\101"+
        "\1\26\1\103\2\26\1\106\1\26\1\uffff\1\110\1\uffff\1\111\1\112\1"+
        "\uffff\1\113\4\uffff";
    static final String DFA7_eofS =
        "\114\uffff";
    static final String DFA7_minS =
        "\1\11\6\56\3\uffff\1\52\2\uffff\1\56\6\uffff\1\56\1\60\2\uffff\2"+
        "\60\1\uffff\5\60\2\uffff\1\60\1\uffff\26\60\1\56\1\60\1\56\2\60"+
        "\1\56\1\60\1\uffff\1\56\1\uffff\2\56\1\uffff\1\56\4\uffff";
    static final String DFA7_maxS =
        "\1\175\6\172\3\uffff\1\57\2\uffff\1\172\6\uffff\2\172\2\uffff\2"+
        "\172\1\uffff\5\172\2\uffff\1\172\1\uffff\35\172\1\uffff\1\172\1"+
        "\uffff\2\172\1\uffff\1\172\4\uffff";
    static final String DFA7_acceptS =
        "\7\uffff\1\10\1\11\1\12\1\uffff\1\15\1\16\1\uffff\1\20\1\21\1\22"+
        "\1\23\1\24\1\25\2\uffff\1\17\1\30\2\uffff\1\26\5\uffff\1\13\1\14"+
        "\1\uffff\1\27\35\uffff\1\1\1\uffff\1\3\2\uffff\1\5\1\uffff\1\2\1"+
        "\6\1\4\1\7";
    static final String DFA7_specialS =
        "\114\uffff}>";
    static final String[] DFA7_transitionS = {
            "\1\13\3\uffff\1\13\22\uffff\1\13\6\uffff\1\14\1\22\1\23\2\21"+
            "\2\uffff\1\26\1\12\12\uffff\1\20\1\17\1\uffff\1\27\1\uffff\1"+
            "\21\1\7\32\24\4\uffff\1\25\1\uffff\6\15\1\4\1\1\1\5\3\15\1\6"+
            "\1\15\1\2\1\3\12\15\1\10\1\16\1\11",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\4\31"+
            "\1\30\25\31",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\17\31"+
            "\1\33\12\31",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\1\34"+
            "\31\31",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\21\31"+
            "\1\35\10\31",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\14\31"+
            "\1\36\15\31",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\4\31"+
            "\1\37\25\31",
            "",
            "",
            "",
            "\1\40\4\uffff\1\41",
            "",
            "",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\32\31",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\26\1\uffff\12\42\7\uffff\32\42\4\uffff\1\43\1\uffff\32\42",
            "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
            "",
            "",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\1\45\31\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\32\31",
            "",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\23\31\1\46\6\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\2\31\1\50\16\31\1"+
            "\47\10\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\1\51\31\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\17\31\1\52\12\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\14\31\1\53\15\31",
            "",
            "",
            "\12\42\7\uffff\32\42\4\uffff\1\43\1\uffff\32\42",
            "",
            "\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\3\31\1\54\26\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\10\31\1\55\21\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\22\31\1\56\7\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\12\31\1\57\17\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\14\31\1\60\15\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\16\31\1\61\13\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\1\31\1\62\30\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\4\31\1\63\25\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\16\31\1\64\13\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\4\31\1\65\25\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\1\66\31\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\14\31\1\67\15\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\21\31\1\70\10\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\4\31\1\71\25\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\21\31\1\72\10\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\15\31\1\73\14\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\21\31\1\74\10\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\6\31\1\75\23\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\1\76\31\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\23\31\1\77\6\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\21\31\1\100\10\31",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\32\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\22\31\1\102\7\31",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\32\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\4\31\1\104\25\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\21\31\1\105\10\31",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\32\31",
            "\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\22\31\1\107\7\31",
            "",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\32\31",
            "",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\32\31",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\32\31",
            "",
            "\1\26\1\uffff\12\31\7\uffff\32\31\4\uffff\1\32\1\uffff\32\31",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA7_eot = DFA.unpackEncodedString(DFA7_eotS);
    static final short[] DFA7_eof = DFA.unpackEncodedString(DFA7_eofS);
    static final char[] DFA7_min = DFA.unpackEncodedStringToUnsignedChars(DFA7_minS);
    static final char[] DFA7_max = DFA.unpackEncodedStringToUnsignedChars(DFA7_maxS);
    static final short[] DFA7_accept = DFA.unpackEncodedString(DFA7_acceptS);
    static final short[] DFA7_special = DFA.unpackEncodedString(DFA7_specialS);
    static final short[][] DFA7_transition;

    static {
        int numStates = DFA7_transitionS.length;
        DFA7_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA7_transition[i] = DFA.unpackEncodedString(DFA7_transitionS[i]);
        }
    }

    class DFA7 extends DFA {

        public DFA7(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 7;
            this.eot = DFA7_eot;
            this.eof = DFA7_eof;
            this.min = DFA7_min;
            this.max = DFA7_max;
            this.accept = DFA7_accept;
            this.special = DFA7_special;
            this.transition = DFA7_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( HEADER | OPTIONS | PARSER | GRAMMAR | IMPORT | PACKAGE | MEMBERS | ARROBA | ABRIRLLAVE | CERRARLLAVE | COMENTARIO | COMENTARIOlINEA | BLANCO | CARACTER | IDENT | OR | SEPARADOR | DOSPUNTOS | OPERADORUNITARIO | ABRIRPARENTESIS | CERRARPARENTESIS | IDENTREGLA | IDENTTOKEN | IGUAL );";
        }
    }
 

}